package com.example.tangjiangxu.glidedemo;

import android.app.Activity;
import android.content.Context;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;

import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";

    private Context mContext;
    /** 1920 * 1080 * 4 / 1024 / 1024 = 7.9Mb **/
    private String BITMAP_URL = "http://cn.bing.com/az/hprichbg/rb/Dongdaemun_ZH-CN10736487148_1920x1080.jpg";
    private String GIF_URL = "http://p1.pstatp.com/large/166200019850062839d3";
    private Button bnLoad;
    private Button bnLoadWithPlace;
    private Button bnNoDiskCache;
    private Button bnError;
    private Button bnLoadGif;
    private Button bnLoadAsBitmap;
    private Button bnLoadAsGif;
    private Button bnLoad1024;
    private Button bnLoad100;
    private Button bnShowSize;
    private TextView tvImageSize;
    private ImageView mImg;
    private ImageView mImgSmall;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mContext = MainActivity.this;
        findViews();
        setListeners();
    }

    private void findViews() {
        bnLoad = (Button) findViewById(R.id.bn_load);
        bnLoadWithPlace = (Button) findViewById(R.id.bn_placeholder);
        bnNoDiskCache = (Button) findViewById(R.id.bn_no_diskcache);
        bnError = (Button) findViewById(R.id.bn_error);
        bnLoadGif = (Button) findViewById(R.id.bn_load_gif);
        bnLoadAsBitmap = (Button) findViewById(R.id.bn_load_as_bitmap);
        bnLoadAsGif = (Button) findViewById(R.id.bn_load_as_gif);
        bnLoad1024 = (Button) findViewById(R.id.bn_load_1024);
        bnLoad100 = (Button) findViewById(R.id.bn_load_100);
        bnShowSize = (Button) findViewById(R.id.bn_show_size);
        tvImageSize = (TextView) findViewById(R.id.tv_image_size);
        mImg = (ImageView) findViewById(R.id.image_view);
        mImgSmall = (ImageView) findViewById(R.id.image_view_small);
    }

    private void setListeners() {
        /** 简单地加载图片 **/
        bnLoad.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                simpleLoadImage(mContext, BITMAP_URL, mImg);
            }
        });

        /** 通过设置占位符地方式加载图片 **/
        bnLoadWithPlace.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ////通过resId方式，最后也是通过getResources().getDrawable(resId)得到Drawable对象以后进行设置
                //loadWithPlaceHolder(mContext, url, R.mipmap.ic_launcher, mImg);

                Drawable defaultImage = getResources().getDrawable(R.drawable.icon_default);
                loadWithPlaceHolder(mContext, BITMAP_URL, defaultImage, mImg);
            }
        });

        /** 通过不设置本地缓存地方式加载图片 **/
        bnNoDiskCache.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                loadWithNoDiskCache(mContext, BITMAP_URL, R.drawable.icon_default, mImg);
            }
        });

        /** 通过加载错误图的方式加载图片 **/
        bnError.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                loadWithError(mContext, BITMAP_URL, R.drawable.icon_default, R.drawable.icon_error, mImg);
            }
        });

        /** 加载Gif **/
        bnLoadGif.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //加载Gif图片的时候，必须要配置diskCacheStrategy设置为NONE或者SOURCE,不配置默认就是ALL
                //即会把GIF图的每一帧都去压缩然后缓存，时间需要比较长
                loadWithNoDiskCache(mContext, GIF_URL, R.drawable.icon_default, mImg);
            }
        });

        /** 只加载静态资源 **/
        bnLoadAsBitmap.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                loadAsBitmap(mContext, GIF_URL, R.drawable.icon_default, R.drawable.icon_error, mImg);
            }
        });

        /** 只加载Gif **/
        bnLoadAsGif.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                loadAsGif(mContext, BITMAP_URL, R.drawable.icon_default, R.drawable.icon_error, mImg);
            }
        });

        /** 加载1024 ＊ 1024的图片 **/
        bnLoad1024.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                loadWithWH(mContext, BITMAP_URL, 1024, 1024, mImg);
            }
        });

        /** 加载100 ＊ 100的图片 **/
        bnLoad100.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //loadWithWH(mContext, BITMAP_URL, 1024, 1024, mImgSmall);
                loadWithWH(mContext, BITMAP_URL, 100, 100, mImgSmall);
            }
        });

        /** 显示图片大小 **/
        bnShowSize.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
               /* double mImgSize = ((BitmapDrawable)mImg.getDrawable()).getBitmap().getByteCount() * 1.0 / 1024 / 1024;
                double mImgSmallSize = ((BitmapDrawable)mImgSmall.getDrawable()).getBitmap().getByteCount() * 1.0 / 1024 / 1024;
                tvImageSize.setText("大图："  + mImgSize + ",小图："  + mImgSmallSize);*/
            }
        });
    }

    /**
     * 简单地加载图片
     * @param context  上下文
     * @param imageUrl 资源
     * @param imageView 显示的控件
     * 总结起来：先with(),再load(),最后into();
     */
    public void simpleLoadImage(Context context, String imageUrl, ImageView imageView) {
        //Glide.with()方法，用于创建一个加载图片的实例。
        //with方法可以接受Activity、Context、Fragment等参数，该参数会决定Glide加载图片的生命周期
        //也就是说如果传入的是Activity,Fragment的对象, 则当该Activity、Fragment被销毁时，图片加载也会停止
        //如果传入的是Application对象，则只有当应用程序被杀掉的时候，图片才会停止加载

        //load方法用于指定待加载图片资源,支持各种样式的图片,如下：
        //load(String str): url、文件path
        //load(File file):文件
        //load(Interger resId):应用资源
        //load(byte[] byteArr):二进制
        //load(Uri):Uri对象

        //into()方法指定让图片显示在哪个ImageView上

        Glide.with(context).load(imageUrl).into(imageView);

        //这时候，就完成了图片的下载、缓存、解码、显示等流程，如果下次没有网络，进入app，也能正常显示
    }

    /**
     * 通过设置占位符地方式，加载图片
     * @param context
     * @param imageUrl
     * @param phId
     * @param imageView
     */
    public void loadWithPlaceHolder(Context context, String imageUrl, int phId, ImageView imageView) {

        //placeholder方法，支持通过resId、Drawable对象两种方式，来设置占位符
        //Glide当中绝大多数Api的用法都类似，就是在load()和into()方法指间串接任意想添加功能的方法
        Glide.with(context)
                .load(imageUrl)
                .placeholder(phId)
                .into(imageView);
    }

    /**
     * 通过设置占位符地方式，加载图片
     * @param context
     * @param imageUrl
     * @param phDrawable
     * @param imageView
     */
    public void loadWithPlaceHolder(Context context, String imageUrl, Drawable phDrawable, ImageView imageView) {
        Glide.with(context)
                .load(imageUrl)
                .placeholder(phDrawable)
                .into(imageView);
    }

    /**
     * 通过不文件缓存的方式，加载图片
     * @param context
     * @param imageUrl
     * @param phId
     * @param imageView
     */
    public void loadWithNoDiskCache(Context context, String imageUrl, int phId, ImageView imageView) {
        Glide.with(context)
                .load(imageUrl)
                .placeholder(phId)
                .diskCacheStrategy(DiskCacheStrategy.NONE)
                .into(imageView);
    }

    /**
     * 通过设置错误图的方式，加载图片
     * @param context
     * @param imageUrl
     * @param phId
     * @param errorId
     * @param imageView
     */
    public void loadWithError(Context context, String imageUrl, int phId, int errorId, ImageView imageView) {
        Glide.with(context)
                .load(imageUrl)
                .placeholder(phId)
                .diskCacheStrategy(DiskCacheStrategy.NONE)
                .error(errorId)
                .into(imageView);
    }

    /**
     * 加载图片，只允许加载静态图片，如果是Gif图片，只展示第一帧
     * @param context
     * @param imageUrl
     * @param phId
     * @param errorId
     * @param imageView
     */
    private void loadAsBitmap(Context context, String imageUrl, int phId, int errorId, ImageView imageView) {
        Glide.with(context)
                .load(imageUrl)
                .asBitmap()
                .placeholder(phId)
                .error(errorId)
                .diskCacheStrategy(DiskCacheStrategy.NONE)
                .into(imageView);
    }

    /**
     * 加载图片，只允许Gif，如果是静态图片，则加载失败
     * @param context
     * @param imageUrl
     * @param phId
     * @param errorId
     * @param imageView
     */
    private void loadAsGif(Context context, String imageUrl, int phId, int errorId, ImageView imageView) {
        Glide.with(context)
                .load(imageUrl)
                .asGif()
                .placeholder(phId)
                .error(errorId)
                .diskCacheStrategy(DiskCacheStrategy.NONE)
                .into(imageView);
    }

    /**
     * 指定宽高的方式，加载图片
     * @param context
     * @param imageUrl
     * @param width
     * @param height
     * @param imageView
     */
    private void loadWithWH(Context context, String imageUrl, int width, int height, ImageView imageView) {
        Glide.with(context)
                .load(imageUrl)
                .diskCacheStrategy(DiskCacheStrategy.NONE)
                .override(width, height)
                .into(imageView);
    }


    private void clearCache(final Activity activity) {
        if (Thread.currentThread() == Looper.getMainLooper().getThread()) {     //主线程
            //清理内存，需要在主线程
            Glide.get(activity).clearMemory();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    //清理文件缓存，需要在子线程
                    Glide.get(activity).clearDiskCache();
                }
            }).start();

        } else {    //子线程
            activity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Glide.get(activity).clearMemory();
                }
            });
            Glide.get(activity).clearDiskCache();
        }
    }

}
